/*
240. 食物链

动物王国中有三类动物 A,B,C，这三类动物的食物链构成了有趣的环形。
A吃 B，B 吃 C，C 吃 A。
现有 N 个动物，以 1∼N 编号。
每个动物都是 A,B,C 中的一种，但是我们并不知道它到底是哪一种。
有人用两种说法对这 N 个动物所构成的食物链关系进行描述：
第一种说法是 1 X Y，表示 X 和 Y 是同类。
第二种说法是 2 X Y，表示 X 吃 Y。
此人对 N 个动物，用上述两种说法，一句接一句地说出 K 句话，这 K 句话有的是真的，有的是假的。
当一句话满足下列三条之一时，这句话就是假话，否则就是真话。
当前的话与前面的某些真的话冲突，就是假话；
当前的话中 X 或 Y 比 N 大，就是假话；
当前的话表示 X 吃 X，就是假话。
你的任务是根据给定的 N 和 K 句话，输出假话的总数。

输入格式
第一行是两个整数 N 和 K，以一个空格分隔。
以下 K 行每行是三个正整数 D，X，Y，两数之间用一个空格隔开，其中 D 表示说法的种类。
若 D=1，则表示 X 和 Y 是同类。
若 D=2，则表示X吃 Y
输出格式
只有一个整数，表示假话的数目。
数据范围
1≤N≤50000,0≤K≤100000
输入样例：
100 7
1 101 1 
2 1 2
2 2 3 
2 3 3 
1 1 3 
2 3 1 
1 5 5
输出样例：
3
-----------------------------
100 7
1 101 1 错：101>100
2 1 2 对
2 2 3 对
2 3 3 错：X吃X错误
1 1 3 错：1->2,2->3,3->1，而不是3同1
2 3 1 对
1 5 5 对
*/
#include<iostream>
using namespace std;
const int N = 50010;

int p[N], d[N];//d[]是距离

int find(int x)
{
    if (x != p[x])
    {
        //p[x]=find(p[x]);会改变p[x]，在find执行时会return
/*以 1->3->5->8:p[8]=5,p[5]=3..这样为例：
p[8]=find(p[8])=find(5):return p[5] =>p[8]=p[5]
这个递归是这样，每一次都会return将p[x]改变，而不是一直走走走最后才return
每find()一次，都会先连下，将父节点往上面连接一个连到“爷”节点上，
而不是直接一下find()完毕，连接到祖宗节点上。

因此，这个d[x]也是每次find()都会执行的，而不是最终p[1]==1的时候执行最后一次
*/
        int t = find(p[x]);
        d[x] += d[p[x]];
        p[x] = t;
    }
    /*if(x!=p[x])
    {
        p[x]=find(p[x]);
        d[x]+=d[p[x]];
    }*/
    return p[x];
}
/*就如下的图，当t=p[1]=1的时候结束递归
*/
int main()
{
    int n, k;
    cin >> n >> k;
    int D, x, y, res = 0;
    for (int i = 1; i <= n; i++)   p[i] = i; //
    while (k--)
    {
        cin >> D >> x >> y;
        if (x > n || y > n)  res++; //当前的话中 X或 Y比 N大，就是假话；
        else
        {
            int px = find(x), py = find(y);//px,py:祖先
            if (D == 1)
            {
                if (px == py && (d[x] - d[y]) % 3) res++; //在同一颗树上，且取模!=0
                else if (px != py) //不在同一颗树上
                    //就强行变成在一颗树上面（同一集合里）并且满足同类的关系
                {
                    p[px] = py;
                    //d[x]%3==(?+d[y])%3  d[x]=?+d[y]
                    d[px] = d[y] - d[x]; //?=d[x]-d[y]
                    //这个？为什么是d[px]??
                }
            }
            else//t==2 相残关系 x吃y d[x]%3==(d[y]+1 )%3 <=> (d[x]-d[y]-1)%3
            //不是d[x]%3==d[y]%3 +1
            {
                if (px == py && (d[x] - d[y] - 1) % 3)   res++;//
                else if (px != py)
                {
                    p[px] = py;
                    d[px] = d[y] - d[x] + 1;
                }
            }
        }
    }
    cout << res << endl;
}

/*总结
1.当D=1)//同类，d[x]-d[y]或者d[y]-d[x]都对
2.x吃y,x比y大，因此要d[x]-d[y]，d[y]-d[x]是错的
3.怎么判断是不是同类？
 如果相等，1 x x:是同类
 分别到根节点的距离%3，相同-》同类，不同则是不同类
 d[x]%3==d[y]%3 《=》 (d[x]-d[y])%3==0
 也就是 在同一颗树上，且取模==0为同类,
 px==py && (d[x]-d[y])%3 这样的情况下是不同类
 ==0为真，因此满足条件!=0时为1-》执行res++;

 px==py:说明x和y在同一颗树上面，
 前提是要在同一颗树上面才能推理1->2->3->1这样的关系
*/